package com.multimedia.scala.euler

import scala.annotation.tailrec
/*
A number chain is created by continuously adding the square of the
digits in a number to form a new number until it has been seen before.

For example,

44  32  13  10  1  1
85  89  145  42  20  4  16  37  58  89

Therefore any chain that arrives at 1 or 89 will become stuck in an endless loop.
What is most amazing is that EVERY starting number will eventually arrive at 1 or 89.

How many starting numbers below ten million will arrive at 89?
 */
object Asd92 {
    def main(args : Array[String]) : Unit = {
        var cache_1 = scala.collection.mutable.Set[Int](1)
        var cache_89 = scala.collection.mutable.Set[Int](89)
        @tailrec
        def check(y: Int, acc: Set[Int] = Set()): Boolean = {
            def sqr(x: Int) = x*x
            def next = y.toString().toCharArray.map(_.asDigit).map(sqr).sum
            //print(y + " ")
            if (cache_1.contains(y)) {
            	cache_1 ++= acc
            	//cache_1 += y
                return false
            } else if (cache_89.contains(y)) {
            	cache_89 ++= acc
            	//cache_89 += y
                return true
            }
            else if (y<10000) check(next, acc+y)
            else check(next, acc)
        }

        val rez = (2 to 9999999).filter(check(_)).length
        println(rez)
        //println(check(44))
    }
}
